Globals in Macros.carp

Macro

                        (*= var val)
                    

Sets the value of a variable to its current value multiplied by val.

Macro

                        (++ var)
                    

Sets the value of a variable to its current value incremented by one.

Macro

                        (+= var val)
                    

Sets the value of a variable to its current value plus val.

Macro

                        (-- var)
                    

Sets the value of a variable to its current value decremented by one.

Macro

                        (-= var val)
                    

Sets the value of a variable to its current value minus val.

Macro

                        (and :rest xs)
                    

evaluates the forms xs one at a time, from left to right. If a form evaluates to false, and returns that value and doesn't evaluate any of the other expressions, otherwise it returns the value of the last form in xs. (and) returns true.

Macro

                        (annotate name annotation)
                    

Add an annotation to this binding.

Macro

                        (c-name sym cname)
                    

Override the identifiers Carp generates for a given symbol in C output.

(defn foo-bar [] 1)
(c-name foo-bar "foo_bar")

Macro

                        (comment :rest forms)
                    

ignores forms.

Macro

                        (cond :rest xs)
                    

Executes a block of code if a specified condition is true. Multiple such blocks can be chained.

(cond
  (< 10 1) (println "Condition 1 is true")
  (> 10 1) (println "Condition 2 is true")
  (println "Else branch"))

Dynamic

                        (const-assert expr msg)
                    

Asserts that the expression expr is true at compile time. Otherwise it will fail with the message msg.

The expression must be evaluable at compile time.

Macro

                        (def- name value)
                    

Declares a variable while marking it as private and hidden.

Macro

                        (defdynamic-once var expr)
                    

Creates a dynamic variable and sets its value if it's not already defined.

Macro

                        (defn- name args form)
                    

Declares a function while marking it as private and hidden.

Macro

                        (deprecated name :rest explanation)
                    

Declares that a binding is deprecated, using an optional explanation.

Macro

                        (doc name :rest strings)
                    

Set documentation for a binding.

Macro

                        (hidden name)
                    

Mark a binding as hidden, this will make it not print with the 'info' command.

Macro

                        (hidden? name)
                    

Is this binding hidden?

Macro

                        (ignore form)
                    

ignores the return value of the expression form.

Macro

                        (ignore* :rest forms)
                    

Wraps all forms passed as an argument in a call to ignore.

Macro

                        (implements-all mod :rest interfaces)
                    

Declares functions in mod with names matching interfaces as implementations of those interfaces.

Macro

                        (inline-c name defcode :rest declcode)
                    

Inlines some custom C code.

Macro

                        (load-and-use name)
                    

loads a file and uses the module with in it. Assumes that the filename and module name are the same.

Macro

                        (or :rest xs)
                    

evaluates the forms xs one at a time, from left to right. If a form evaluates to true, or returns that value and doesn't evaluate any of the other expressions, otherwise it returns the value of the last form in xs. (or) returns false.

Macro

                        (print-doc name)
                    

Print the documentation for a binding.

Macro

                        (print-sig name)
                    

Print the annotated signature for a binding.

Macro

                        (private name)
                    

Mark a binding as private, this will make it inaccessible from other modules.

Macro

                        (private? name)
                    

Is this binding private?

Macro

                        (refstr x)
                    

stringifies x and takes the reference of that string.

Macro

                        (sig name signature)
                    

Annotate a binding with the desired signature.

Macro

                        (swap! x y)
                    

swaps its arguments x and y in place.

Note: Unhygienic!

Macro

                        (todo name value)
                    

sets the todo property for a binding.

Macro

                        (unreachable msg)
                    

Asserts that a block of code will never be reached. If it is the program will be aborted with an error message.

Macro

                        (update! x f)
                    

updates x in place using the function f.

Macro

                        (use-all :rest names)
                    

is a variadic version of use.